OpenClaw 子代理协作实战指南

单个 AI 助理能力有限，多个子代理协作可以完成更复杂的任务。本文介绍如何设计多代理系统，实现任务分解、并行处理、结果整合，构建真正的 AI 团队协作。

一、为什么需要多代理协作？

单代理的局限

上下文限制：单次对话长度有限
专业局限：一个代理难以精通所有领域
效率局限：串行处理任务耗时长
可靠性局限：单点故障风险

多代理的优势

单代理模式：
用户 → AI 助理 → 结果
（所有任务一人完成，慢且容易出错）

多代理模式：
用户 → 协调代理 → 分解任务
              ├→ 代码代理 → 编写代码
              ├→ 测试代理 → 执行测试
              ├→ 文档代理 → 编写文档
              └→ 整合结果 → 最终交付
（专业分工，并行处理，更快更可靠）

二、多代理架构设计

经典架构：协调者 - 工作者

javascript

// 协调者代理（Coordinator）
// 职责：理解任务、分解任务、分配工作、整合结果

// 工作者代理（Worker）
// 职责：执行具体任务、返回结果

// 示例：软件开发团队
const team = {
  coordinator: "项目经理",  // 理解需求，分配任务
  workers: {
    developer: "开发工程师",   // 编写代码
    tester: "测试工程师",      // 执行测试
    writer: "技术文档",        // 编写文档
    reviewer: "代码审查",      // 审查质量
  }
}

流水线架构

任务 → 代理 1 → 代理 2 → 代理 3 → 结果
      (输入)  (处理)  (输出)

示例：内容创作流水线
选题 → 调研 → 大纲 → 写作 → 校对 → 发布

委员会架构

           ┌→ 代理 1 ┐
任务 → 分发 ├→ 代理 2 ├→ 投票/整合 → 结果
           └→ 代理 3 ┘

示例：决策系统
多个代理独立分析，投票决定最佳方案

三、实战案例 1：自动化软件开发团队

场景说明

用户提出功能需求，自动组织开发团队完成编码、测试、文档。

完整实现

javascript

// 软件开发团队协调器
class DevTeamCoordinator {
  constructor() {
    this.team = {
      analyst: "requirements-analyst",
      developer: "code-developer",
      tester: "test-engineer",
      reviewer: "code-reviewer",
      writer: "doc-writer"
    }
  }
  
  // 处理用户需求
  async handleRequest(userRequest) {
    console.log("📋 收到需求:", userRequest)
    
    // 步骤 1：需求分析
    const requirements = await this.analyzeRequirements(userRequest)
    console.log("✅ 需求分析完成")
    
    // 步骤 2：任务分解
    const tasks = this.decomposeTasks(requirements)
    console.log(`✅ 分解为 ${tasks.length} 个任务`)
    
    // 步骤 3：并行执行
    const results = await this.parallelExecute(tasks)
    console.log("✅ 任务执行完成")
    
    // 步骤 4：代码审查
    const reviewResult = await this.reviewCode(results.code)
    console.log("✅ 代码审查完成")
    
    // 步骤 5：整合交付
    const deliverable = this.integrateResults({
      requirements,
      code: results.code,
      tests: results.tests,
      docs: results.docs,
      review: reviewResult
    })
    
    return deliverable
  }
  
  // 需求分析
  async analyzeRequirements(request) {
    const agent = sessions_spawn(
      task=`
分析以下用户需求，提取功能点：

${request}

输出格式：
1. 功能列表
2. 技术栈建议
3. 接口设计
4. 数据结构
      `,
      agentId=this.team.analyst,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return agent.result
  }
  
  // 任务分解
  decomposeTasks(requirements) {
    return [
      {
        type: "code",
        agent: this.team.developer,
        task: `根据需求编写代码：${requirements}`
      },
      {
        type: "test",
        agent: this.team.tester,
        task: `编写测试用例并执行：${requirements}`
      },
      {
        type: "doc",
        agent: this.team.writer,
        task: `编写技术文档：${requirements}`
      }
    ]
  }
  
  // 并行执行
  async parallelExecute(tasks) {
    const results = {}
    
    // 并行启动所有任务
    for (const task of tasks) {
      sessions_spawn(
        task=task.task,
        agentId=task.agent,
        mode="run",
        label=task.type,
        streamTo="parent"
      )
    }
    
    // 等待所有任务完成
    sessions_yield()
    
    // 收集结果
    // 实际实现需要从会话结果中提取
    results.code = "// 生成的代码"
    results.tests = "// 测试代码"
    results.docs = "// 文档内容"
    
    return results
  }
  
  // 代码审查
  async reviewCode(code) {
    const agent = sessions_spawn(
      task=`
审查以下代码：
1. 代码质量
2. 安全问题
3. 性能问题
4. 改进建议

${code}
      `,
      agentId=this.team.reviewer,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return agent.result
  }
  
  // 整合结果
  integrateResults(results) {
    return {
      status: "completed",
      deliverables: {
        code: results.code,
        tests: results.tests,
        docs: results.docs
      },
      quality: {
        review: results.review,
        testCoverage: "95%"
      },
      timestamp: new Date().toISOString()
    }
  }
}

// 使用示例
const team = new DevTeamCoordinator()
const result = await team.handleRequest(`
开发一个用户登录功能：
- 支持邮箱和密码登录
- 支持第三方登录（GitHub、Google）
- 包含注册、登录、登出
- 密码加密存储
- 防止暴力破解
`)

console.log("✅ 开发完成:", result)

输出示例

📋 收到需求：开发一个用户登录功能...
✅ 需求分析完成
✅ 分解为 3 个任务
✅ 任务执行完成
✅ 代码审查完成

交付物：
- 代码：auth_controller.js, user_model.js, login_routes.js
- 测试：15 个单元测试，覆盖率 95%
- 文档：API 文档、使用说明
- 审查：无严重问题，3 个改进建议

四、实战案例 2：内容创作工作室

场景说明

自动化内容创作流程：选题→调研→大纲→写作→校对→发布。

完整实现

javascript

// 内容创作工作室
class ContentStudio {
  constructor() {
    this.roles = {
      researcher: "content-researcher",
      planner: "content-planner",
      writer: "content-writer",
      editor: "content-editor",
      publisher: "content-publisher"
    }
  }
  
  // 完整创作流程
  async createContent(topic, targetAudience, wordCount) {
    console.log(`📝 开始创作：${topic}`)
    
    // 步骤 1：市场调研
    const research = await this.research(topic)
    console.log("✅ 调研完成")
    
    // 步骤 2：创建大纲
    const outline = await this.createOutline(topic, research, targetAudience)
    console.log("✅ 大纲完成")
    
    // 步骤 3：撰写正文
    const draft = await this.writeContent(outline, wordCount)
    console.log("✅ 初稿完成")
    
    // 步骤 4：编辑校对
    const final = await this.editContent(draft)
    console.log("✅ 校对完成")
    
    // 步骤 5：发布
    const published = await this.publish(final)
    console.log("✅ 发布完成")
    
    return published
  }
  
  // 市场调研
  async research(topic) {
    const researcher = sessions_spawn(
      task=`
调研主题：${topic}

1. 搜索最新资料（使用 web_search）
2. 收集相关数据和案例
3. 分析竞争对手内容
4. 找出独特视角

输出调研报告（1000 字左右）
      `,
      agentId=this.roles.researcher,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return researcher.result
  }
  
  // 创建大纲
  async createOutline(topic, research, audience) {
    const planner = sessions_spawn(
      task=`
基于以下调研结果，创建文章大纲：

主题：${topic}
目标读者：${audience}
调研结果：${research}

大纲要求：
1. 吸引人的标题（5 个备选）
2. 引言（痛点 + 承诺）
3. 主体部分（3-5 个大点）
4. 结论（总结 + 行动建议）
5. 预估字数分配
      `,
      agentId=this.roles.planner,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return planner.result
  }
  
  // 撰写正文
  async writeContent(outline, wordCount) {
    const writer = sessions_spawn(
      task=`
根据以下大纲撰写文章：

${outline}

要求：
- 总字数：${wordCount}字
- 语气：专业但易懂
- 包含实战案例
- 添加代码示例（如适用）
- 每段不要太长
      `,
      agentId=this.roles.writer,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return writer.result
  }
  
  // 编辑校对
  async editContent(draft) {
    const editor = sessions_spawn(
      task=`
编辑校对以下文章：

1. 检查逻辑连贯性
2. 修正语法错误
3. 优化表达方式
4. 确保事实准确
5. 添加必要的过渡

输出最终版本
      `,
      agentId=this.roles.editor,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return editor.result
  }
  
  // 发布
  async publish(content) {
    const publisher = sessions_spawn(
      task=`
发布以下内容：

1. 格式化（Markdown）
2. 添加元数据（标题、标签、摘要）
3. 保存到指定位置
4. 生成发布通知
      `,
      agentId=this.roles.publisher,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return publisher.result
  }
}

// 使用示例
const studio = new ContentStudio()
const article = await studio.createContent(
  "OpenClaw 多代理协作",
  "开发者和技术管理者",
  5000
)

console.log("✅ 文章发布:", article.url)

创作流程时间对比

单人创作：
调研 (2h) + 大纲 (1h) + 写作 (3h) + 校对 (1h) = 7 小时

多代理协作（并行）：
调研 (2h) → 大纲 (1h) → 写作 (3h) → 校对 (1h)
但写作和校对可以重叠，实际约 5 小时

效率提升：约 30%

五、实战案例 3：智能客服系统

场景说明

多个客服代理协作处理客户咨询，复杂问题自动升级。

完整实现

javascript

// 智能客服系统
class CustomerServiceTeam {
  constructor() {
    this.agents = {
      triage: "support-triage",      // 分诊代理
      billing: "billing-support",     // 账单支持
      technical: "tech-support",      // 技术支持
      sales: "sales-support",         // 销售支持
      manager: "support-manager"      // 主管（处理升级）
    }
    this.tickets = new Map()
  }
  
  // 处理客户咨询
  async handleInquiry(customerId, inquiry, channel) {
    const ticketId = this.createTicket(customerId, inquiry, channel)
    
    // 步骤 1：分诊（判断问题类型）
    const category = await this.triageInquiry(inquiry)
    
    // 步骤 2：分配给对应代理
    const assignedAgent = this.assignAgent(category)
    
    // 步骤 3：处理问题
    const response = await this.handleWithAgent(assignedAgent, inquiry)
    
    // 步骤 4：检查是否需要升级
    if (this.needsEscalation(response, inquiry)) {
      const escalatedResponse = await this.escalateToManager(inquiry, response)
      this.updateTicket(ticketId, { status: "escalated", response: escalatedResponse })
      return escalatedResponse
    }
    
    // 步骤 5：关闭工单
    this.updateTicket(ticketId, { status: "resolved", response })
    return response
  }
  
  // 创建工单
  createTicket(customerId, inquiry, channel) {
    const ticketId = `TKT-${Date.now()}`
    this.tickets.set(ticketId, {
      customerId,
      inquiry,
      channel,
      status: "open",
      createdAt: new Date().toISOString()
    })
    return ticketId
  }
  
  // 分诊
  async triageInquiry(inquiry) {
    const triageAgent = sessions_spawn(
      task=`
分析客户咨询，判断问题类型：

${inquiry}

分类：
- billing: 账单、付费、退款
- technical: 技术问题、bug、使用问题
- sales: 产品咨询、购买意向
- other: 其他

只输出分类名称
      `,
      agentId=this.agents.triage,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return triageAgent.result.trim().toLowerCase()
  }
  
  // 分配代理
  assignAgent(category) {
    const mapping = {
      'billing': this.agents.billing,
      'technical': this.agents.technical,
      'sales': this.agents.sales,
      'other': this.agents.technical  // 默认转技术支持
    }
    return mapping[category] || this.agents.technical
  }
  
  // 代理处理
  async handleWithAgent(agentId, inquiry) {
    const agent = sessions_spawn(
      task=`
作为客服代表，回复客户咨询：

${inquiry}

要求：
1. 礼貌专业
2. 准确解答
3. 提供具体步骤（如适用）
4. 告知后续操作
      `,
      agentId=agentId,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return agent.result
  }
  
  // 判断是否需要升级
  needsEscalation(response, inquiry) {
    // 简单规则：包含"无法"、"抱歉"等词可能需要升级
    const negativeWords = ["无法", "抱歉", "需要上级", "escalate"]
    return negativeWords.some(word => response.includes(word))
  }
  
  // 升级到主管
  async escalateToManager(inquiry, initialResponse) {
    const manager = sessions_spawn(
      task=`
客服问题需要升级处理：

客户咨询：${inquiry}
初步回复：${initialResponse}

请以客服主管身份：
1. 道歉并理解客户
2. 提供替代方案
3. 告知后续跟进计划
      `,
      agentId=this.agents.manager,
      mode="run",
      streamTo="parent"
    )
    
    sessions_yield()
    return manager.result
  }
  
  // 更新工单
  updateTicket(ticketId, updates) {
    const ticket = this.tickets.get(ticketId)
    Object.assign(ticket, updates)
    ticket.updatedAt = new Date().toISOString()
    this.tickets.set(ticketId, ticket)
  }
}

// 使用示例
const support = new CustomerServiceTeam()

// 客户咨询
const response = await support.handleInquiry(
  "CUST-12345",
  "我的订单还没有发货，已经等了 5 天了",
  "chat"
)

console.log("回复客户:", response)

客服对话示例

客户：我的订单还没有发货，已经等了 5 天了

分诊：billing（账单/物流问题）
分配：账单支持代理

账单支持：
您好，非常理解您的焦急心情。

我查询了您的订单 #12345：
- 下单时间：2026-03-14
- 当前状态：已付款，待发货
- 延迟原因：仓库库存不足

解决方案：
1. 我们已紧急调货，预计明天发货
2. 为表歉意，赠送您一张 9 折优惠券
3. 发货后会短信通知您

请问还有其他可以帮您的吗？

状态：已解决

六、高级技巧

1. 代理间通信

javascript

// 使用 sessions_send 实现代理间通信
async function agentCollaboration() {
  // 代理 1：数据分析
  const dataAgent = sessions_spawn(
    task="分析销售数据，找出趋势",
    mode="session",
    label="data-analyst"
  )
  
  // 代理 2：报告生成
  const reportAgent = sessions_spawn(
    task="等待数据结果，生成可视化报告",
    mode="session",
    label="report-generator"
  )
  
  // 协调通信
  sessions_send(
    sessionKey=dataAgent.sessionKey,
    message="开始分析 2026 年销售数据"
  )
  
  // 等待数据完成
  sessions_yield()
  
  // 发送数据给报告代理
  sessions_send(
    sessionKey=reportAgent.sessionKey,
    message=`数据结果：${dataAgent.result}`
  )
  
  // 等待报告完成
  sessions_yield()
  
  return reportAgent.result
}

2. 动态任务分配

javascript

// 根据负载动态分配任务
class LoadBalancer {
  constructor() {
    this.agentLoad = new Map()
  }
  
  // 获取负载最低的代理
  getLeastLoadedAgent(availableAgents) {
    let minLoad = Infinity
    let selectedAgent = null
    
    for (const agent of availableAgents) {
      const load = this.agentLoad.get(agent) || 0
      if (load < minLoad) {
        minLoad = load
        selectedAgent = agent
      }
    }
    
    // 更新负载
    this.agentLoad.set(selectedAgent, minLoad + 1)
    return selectedAgent
  }
  
  // 任务完成，减少负载
  taskCompleted(agent) {
    const load = this.agentLoad.get(agent) || 0
    this.agentLoad.set(agent, Math.max(0, load - 1))
  }
}

3. 结果投票机制

javascript

// 多个代理独立判断，投票决定
async function votingDecision(task, agents) {
  const votes = []
  
  // 所有代理独立判断
  for (const agent of agents) {
    sessions_spawn(
      task=task,
      agentId=agent,
      mode="run",
      streamTo="parent"
    )
  }
  
  sessions_yield()
  
  // 收集投票
  // 实际实现需要从结果中提取
  const results = ["option_a", "option_b", "option_a"]
  
  // 计票
  const voteCount = {}
  results.forEach(r => {
    voteCount[r] = (voteCount[r] || 0) + 1
  })
  
  // 选出获胜选项
  const winner = Object.entries(voteCount)
    .sort((a, b) => b[1] - a[1])[0][0]
  
  return { winner, voteCount }
}

七、最佳实践

1. 明确角色分工

✅ 好的设计：
- 每个代理职责清晰
- 避免职责重叠
- 定义明确的输入输出

❌ 差的设计：
- 所有代理做同样的事
- 职责边界模糊
- 输入输出不明确

2. 设置超时和重试

javascript

// 防止代理卡住
sessions_spawn(
  task="...",
  timeoutSeconds=300,        // 5 分钟超时
  runTimeoutSeconds=600,     // 运行超时
  mode="run"
)

// 重试机制
async function spawnWithRetry(task, maxRetries=3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const result = sessions_spawn(task, mode="run")
      sessions_yield()
      return result
    } catch (e) {
      if (i === maxRetries - 1) throw e
      console.log(`重试 ${i+1}/${maxRetries}`)
    }
  }
}

3. 监控和日志

javascript

// 记录代理执行情况
const executionLog = []

function logExecution(agent, task, status, duration) {
  executionLog.push({
    agent,
    task: task.substring(0, 50),
    status,
    duration,
    timestamp: new Date().toISOString()
  })
}

// 定期清理日志
if (executionLog.length > 1000) {
  executionLog.splice(0, 500)
}

八、常见问题

Q: 多少个代理合适？

A: 取决于任务复杂度：

简单任务：1-2 个代理
中等任务：3-5 个代理
复杂任务：5-10 个代理

过多会增加协调成本。

Q: 代理可以嵌套调用吗？

A: 可以，但不建议超过 3 层：

主代理 → 子代理 1 → 子代理 2 → 子代理 3

超过 3 层会导致调试困难。

Q: 如何调试多代理系统？

使用 sessions_history 查看每个代理的执行历史
记录详细的执行日志
单个代理先测试，再集成
使用 subagents action=list 查看所有代理状态

Q: 成本如何控制？

设置合理的超时时间
简单任务使用小模型
及时清理完成的代理
避免不必要的并行

九、总结

多代理协作是构建复杂 AI 系统的关键：

架构	适用场景	特点
协调者 - 工作者	任务可分解	集中管理，清晰分工
流水线	顺序处理	环环相扣，质量保证
委员会	决策场景	集思广益，减少偏差

掌握多代理协作，你可以构建：

自动化开发团队
内容创作工作室
智能客服系统
数据分析平台

记住：好的协作 = 明确分工 + 有效沟通 + 结果整合

相关资源：

OpenClaw 子代理协作实战指南 ​

一、为什么需要多代理协作？ ​

单代理的局限 ​

多代理的优势 ​

二、多代理架构设计 ​

经典架构：协调者 - 工作者 ​

流水线架构 ​

委员会架构 ​

三、实战案例 1：自动化软件开发团队 ​

场景说明 ​

完整实现 ​

输出示例 ​

四、实战案例 2：内容创作工作室 ​

场景说明 ​

完整实现 ​

创作流程时间对比 ​

五、实战案例 3：智能客服系统 ​

场景说明 ​

完整实现 ​

客服对话示例 ​

六、高级技巧 ​

1. 代理间通信 ​

2. 动态任务分配 ​

3. 结果投票机制 ​

七、最佳实践 ​

1. 明确角色分工 ​

2. 设置超时和重试 ​

3. 监控和日志 ​

八、常见问题 ​

Q: 多少个代理合适？ ​

Q: 代理可以嵌套调用吗？ ​

Q: 如何调试多代理系统？ ​

Q: 成本如何控制？ ​

九、总结 ​

OpenClaw 子代理协作实战指南

一、为什么需要多代理协作？

单代理的局限

多代理的优势

二、多代理架构设计

经典架构：协调者 - 工作者

流水线架构

委员会架构

三、实战案例 1：自动化软件开发团队

场景说明

完整实现

输出示例

四、实战案例 2：内容创作工作室

场景说明

完整实现

创作流程时间对比

五、实战案例 3：智能客服系统

场景说明

完整实现

客服对话示例

六、高级技巧

1. 代理间通信

2. 动态任务分配

3. 结果投票机制

七、最佳实践

1. 明确角色分工

2. 设置超时和重试

3. 监控和日志

八、常见问题

Q: 多少个代理合适？

Q: 代理可以嵌套调用吗？

Q: 如何调试多代理系统？

Q: 成本如何控制？

九、总结